COMMENT ⊗   VALID 00013 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00003 00002	  procedures for generating and dealing with reduced pictures
C00005 00003	INTEGER PROCEDURE REDDIM(INTEGER HIG,WID,BIT)
C00006 00004	INTEGER PROCEDURE RDFDIM(STRING PICFIL)
C00007 00005	INTEGER PROCEDURE MAKRED(INTEGER HIG,WID,BIT REFERENCE INTEGER REDPIC)
C00009 00006	INTEGER PROCEDURE GETRDF(STRING PICFIL REFERENCE INTEGER REDPIC)
C00011 00007	INTEGER PROCEDURE CAMRED(INTEGER CAMRA,YEDGE,XEDGE
C00013 00008	PROCEDURE PICRED(REFERENCE INTEGER REDPIC)
C00014 00009	INTEGER PROCEDURE WINDIM(INTEGER HIG,WID,BIT, WINDOW)
C00015 00010	INTEGER PROCEDURE WNFDIM(STRING PICFIL INTEGER WINDOW)
C00016 00011	INTEGER PROCEDURE REDWIN(REFERENCE INTEGER REDPIC REAL Y,X
C00019 00012	PROCEDURE FINDIN(REFERENCE INTEGER PIC INTEGER WINDOWSIZE  comment interest op
C00025 00013	REAL PROCEDURE LOCATE(REFERENCE INTEGER PIC1,PIC2 comment correlator
C00028 ENDMK
C⊗;
comment   procedures for generating and dealing with reduced pictures
          and subwindows

reduced picture and window arrays have the following format

   word 0: NPIC number of pictures in the array
   word 1: starting index of picture 1
      ...
   word NPIC: starting index of picture NPIC

   word NPIC+1 to EOF: pictures in GUIDE.VIS format         


picture 1 of reduced picture arrays is a full size, full resolution image.
picture 2 is the same image reduced in size by a linear factor of two,
each pixel being the sum of four pixels of picture 1. Picture 3 is
picture 2, reduced by a further factor of 2, and so on for succeeding
pictures. The final picture is one pixel in its smallest dimension.

Window arrays are produced by pulling WINDOWxWINDOW subarrays
from each of the reduction levels in a reduced picture array.
picture 1 in a window array is a WINDOWxWINDOW piece of
a high resolution image centered around some point in the image.
picture 2 is an identically sized image centered around the
corresponding point in the first reduction. This implies that
it covers twice the linear dimensions of picture 1. The final
picture is drawn from an image whose minimum dimension is
just over WINDOW in length.


;
INTEGER PROCEDURE REDDIM(INTEGER HIG,WID,BIT);
comment   array size needed for set of pictures begining with one of
          size HIG x WID x BIT;
   BEGIN
   INTEGER TSIZ,I,NORD;
   TSIZ←PIXDIM(HIG,WID,BIT);
   I←WID MIN HIG; NORD←0;
   WHILE I>1 DO
      BEGIN
      NORD←NORD+1; I←I ASH -1;
      TSIZ←TSIZ+PIXDIM(HIG ASH -NORD,WID ASH -NORD,(BIT+2*NORD) MIN 9);
      END;
   RETURN(TSIZ+NORD+1+1);
   END;

INTEGER PROCEDURE RDFDIM(STRING PICFIL);
comment  array size for reduced picture set begining with pic in PICFIL;
   BEGIN
   INTEGER ARRAY T[0:10];
   IF GETPFD(PICFIL,T[0])≤0 THEN RETURN(0) ELSE
   RETURN(REDDIM(T[PCLN],T[LNBY],T[BYBI]));
   END;
INTEGER PROCEDURE MAKRED(INTEGER HIG,WID,BIT; REFERENCE INTEGER REDPIC);
comment  make a skeleton array of reduced pictures whose first member
         is of size HIG x WID x PIC;
   BEGIN
   INTEGER I,J,NORD,NPIC;

   I←WID MIN HIG; NORD←0;
   WHILE I>1 DO
      BEGIN
      NORD←NORD+1; I←I ASH -1;
      END;
   NPIC←NORD+1;

   MEMORY[LOCATION(REDPIC)  ]←NPIC;
   MEMORY[LOCATION(REDPIC)+1]←NPIC+1;
   MAKPIX(HIG,WID,BIT,MEMORY[LOCATION(REDPIC)+NPIC+1]);

   J←NPIC+1+PIXDIM(HIG,WID,BIT);
   FOR I←1 STEP 1 UNTIL NORD DO 
      BEGIN
      MEMORY[LOCATION(REDPIC)+I+1]←J;
      J←J+PIXDIM(HIG ASH -I,WID ASH -I,(BIT+2*I) MIN 9);
      MAKPIX(HIG ASH -I,WID ASH -I,(BIT+2*I) MIN 9,
             MEMORY[LOCATION(REDPIC)+MEMORY[LOCATION(REDPIC)+I+1]]);
      END;
   RETURN(J);
   END;
INTEGER PROCEDURE GETRDF(STRING PICFIL; REFERENCE INTEGER REDPIC);
comment  read in a picture file, and make a set of reductions of it;
   BEGIN
   INTEGER ARRAY T[0:10];
   INTEGER I,J,NORD,NPIC, HIG,WID,BIT;

   IF GETPFD(PICFIL,T[0])≤0 THEN RETURN(0);
   HIG←T[PCLN]; WID←T[LNBY]; BIT←T[BYBI];

   I←WID MIN HIG; NORD←0;
   WHILE I>1 DO
      BEGIN
      NORD←NORD+1; I←I ASH -1;
      END;
   NPIC←NORD+1;

   MEMORY[LOCATION(REDPIC)  ]←NPIC;
   MEMORY[LOCATION(REDPIC)+1]←NPIC+1;
   GETPFL(PICFIL,MEMORY[LOCATION(REDPIC)+NPIC+1]);

   J←NPIC+1+PIXDIM(HIG,WID,BIT);
   FOR I←1 STEP 1 UNTIL NORD DO 
      BEGIN
      MEMORY[LOCATION(REDPIC)+I+1]←J;
      J←J+PIXDIM(HIG ASH -I,WID ASH -I,(BIT+2*I) MIN 9);
      HAFPIC(MEMORY[LOCATION(REDPIC)+MEMORY[LOCATION(REDPIC)+I  ]],
             MEMORY[LOCATION(REDPIC)+MEMORY[LOCATION(REDPIC)+I+1]], 9);
      END;
   RETURN(J);
   END;
INTEGER PROCEDURE CAMRED(INTEGER CAMRA,YEDGE,XEDGE;
                                  REFERENCE INTEGER REDPIC;
                                  INTEGER SUMS(1),BCLIP(7),TCLIP(0),NTRY(10));
comment  read in a picture from a camera, and make a set of reductions of it;
   BEGIN
   INTEGER I,NORD,NPIC,RETRY;

   NPIC←REDPIC;  NORD←NPIC-1;
   RETRY←CAMPIX(CAMRA,YEDGE,XEDGE,MEMORY[LOCATION(REDPIC)+MEMORY[LOCATION(REDPIC)+1]],
                                  SUMS,BCLIP,TCLIP,NTRY);
   FOR I←1 STEP 1 UNTIL NORD DO 
      HAFPIC(MEMORY[LOCATION(REDPIC)+MEMORY[LOCATION(REDPIC)+I  ]],
             MEMORY[LOCATION(REDPIC)+MEMORY[LOCATION(REDPIC)+I+1]], 9);
   RETURN(RETRY);
   END;
PROCEDURE PICRED(REFERENCE INTEGER REDPIC);
comment  given a starting picture, make a set of reductions of it;
   BEGIN
   INTEGER I,NORD,NPIC;

   NPIC←REDPIC;  NORD←NPIC-1;
   FOR I←1 STEP 1 UNTIL NORD DO 
      HAFPIC(MEMORY[LOCATION(REDPIC)+MEMORY[LOCATION(REDPIC)+I  ]],
             MEMORY[LOCATION(REDPIC)+MEMORY[LOCATION(REDPIC)+I+1]], 9);
   END;
INTEGER PROCEDURE WINDIM(INTEGER HIG,WID,BIT, WINDOW);
comment dimension of set of WINDOWxWINDOW subparts of a sequence
        made from a HIGxWIDxBIT original;
   BEGIN
   INTEGER TSIZ,I,NORD;
   TSIZ←PIXDIM(WINDOW,WINDOW,BIT);
   I←WID MIN HIG; NORD←0;
   WHILE I≥2*WINDOW DO
      BEGIN
      NORD←NORD+1; I←I ASH -1;
      TSIZ←TSIZ+PIXDIM(WINDOW,WINDOW,(BIT+2*NORD) MIN 9);
      END;
   RETURN(TSIZ+NORD+1+1);
   END;

INTEGER PROCEDURE WNFDIM(STRING PICFIL; INTEGER WINDOW);
comment  array size for window set begining with pic in PICFIL;
   BEGIN
   INTEGER ARRAY T[0:10];
   IF GETPFD(PICFIL,T[0])≤0 THEN RETURN(0) ELSE
   RETURN(WINDIM(T[PCLN],T[LNBY],T[BYBI], WINDOW));
   END;
INTEGER PROCEDURE REDWIN(REFERENCE INTEGER REDPIC; REAL Y,X;
                 INTEGER WINDOW; REFERENCE INTEGER WINPIC);
comment  extract a window set from a reduced picture set;
   BEGIN
   INTEGER I,J,NORD,NPIC,BIT;

   I←MEMORY[LOCATION(REDPIC)+MEMORY[LOCATION(REDPIC)+1]+PCLN] MIN
     MEMORY[LOCATION(REDPIC)+MEMORY[LOCATION(REDPIC)+1]+LNBY];
   NORD←0;
   WHILE I≥2*WINDOW DO
      BEGIN
      NORD←NORD+1; I←I ASH -1;
      END;
   NPIC←NORD+1;

   MEMORY[LOCATION(WINPIC)  ]←NPIC;
   MEMORY[LOCATION(WINPIC)+1]←NPIC+1;
   MAKPIX(WINDOW,WINDOW,
      BIT←MEMORY[LOCATION(REDPIC)+MEMORY[LOCATION(REDPIC)+1]+BYBI],
      MEMORY[LOCATION(WINPIC)+NPIC+1]);

   J←NPIC+1+PIXDIM(WINDOW,WINDOW,BIT);
   FOR I←1 STEP 1 UNTIL NORD DO 
      BEGIN
      MEMORY[LOCATION(WINPIC)+I+1]←J;
      J←J+PIXDIM(WINDOW,WINDOW,(BIT+2*I) MIN 9);
      MAKPIX(WINDOW,WINDOW,(BIT+2*I) MIN 9,
             MEMORY[LOCATION(WINPIC)+MEMORY[LOCATION(WINPIC)+I+1]]);
      END;

   FOR I←0 STEP 1 UNTIL NORD DO 
      TILE(MEMORY[LOCATION(REDPIC)+MEMORY[LOCATION(REDPIC)+I+1]],
      Y*MEMORY[LOCATION(REDPIC)+MEMORY[LOCATION(REDPIC)+I+1]+PCLN]-WINDOW%2,
      X*MEMORY[LOCATION(REDPIC)+MEMORY[LOCATION(REDPIC)+I+1]+LNBY]-WINDOW%2,
           WINDOW,WINDOW,
      MEMORY[LOCATION(WINPIC)+MEMORY[LOCATION(WINPIC)+I+1]],0,0);

   RETURN(J);
   END;
PROCEDURE FINDIN(REFERENCE INTEGER PIC; INTEGER WINDOWSIZE;  comment interest op;
                 REFERENCE INTEGER NFS; REFERENCE REAL FY,FX);
comment  applies the local max of minimum directional variance interest
         operator to produce a list of interesting points in arrays
	 FY and FX, sorted in order of decreasing variance. NFS
         is initialized to maximum number of features, is set by
	 procedure to actual number found;
   BEGIN
   INTEGER IORD,HIG,WID,BIT,IW,HW;

   IORD←0; WHILE (WINDOWSIZE ASH -(IORD+1))≥2 DO IORD←IORD+1;
   IW←WINDOWSIZE ASH -IORD;
   HW←(IW+1)%2;
   IW←2*HW;
   
   HIG←MEMORY[LOCATION(PIC)+MEMORY[LOCATION(PIC)+IORD+1]+PCLN];
   WID←MEMORY[LOCATION(PIC)+MEMORY[LOCATION(PIC)+IORD+1]+LNBY];
   BIT←MEMORY[LOCATION(PIC)+MEMORY[LOCATION(PIC)+IORD+1]+BYBI];

      BEGIN
      INTEGER IAV,I,J,K,AH,AW,FHAV,AWR,AHR;
      SAFE INTEGER ARRAY
      INTER[ 0 : AH ← (HIG-HW-1)%IW + (HIG-1)%IW - 1,
             0 : AW ← (WID-HW-1)%IW + (WID-1)%IW - 1 ];
      REAL ARRAY FXV,FYV,FIV[1:NFS];

         BEGIN
         INTEGER AH,AW;
         SAFE INTEGER ARRAY I00[-2:AH←(HIG-1)%IW-1, 0:AW←(WID-1)%IW-1];
         IAV←INTOP(MEMORY[LOCATION(PIC)+MEMORY[LOCATION(PIC)+IORD+1]],
                   IW,I00[0,0],0,0);
         FOR I←0 STEP 1 UNTIL AH DO
         FOR J←0 STEP 1 UNTIL AW DO
            INTER[I*2,J*2]←I00[I,J];
         END;

         BEGIN
         INTEGER AH,AW;
         SAFE INTEGER ARRAY I10[-2:AH←(HIG-HW-1)%IW-1, 0:AW←(WID-1)%IW-1];
         IAV←IAV+INTOP(MEMORY[LOCATION(PIC)+MEMORY[LOCATION(PIC)+IORD+1]],
                       IW,I10[0,0],HW,0);
         FOR I←0 STEP 1 UNTIL AH DO
         FOR J←0 STEP 1 UNTIL AW DO
            INTER[I*2+1,J*2]←I10[I,J];
         END;

         BEGIN
         INTEGER AH,AW;
         SAFE INTEGER ARRAY I01[-2:AH←(HIG-1)%IW-1, 0:AW←(WID-HW-1)%IW-1];
         IAV←IAV+INTOP(MEMORY[LOCATION(PIC)+MEMORY[LOCATION(PIC)+IORD+1]],
                       IW,I01[0,0],0,HW);
         FOR I←0 STEP 1 UNTIL AH DO
         FOR J←0 STEP 1 UNTIL AW DO
            INTER[I*2,J*2+1]←I01[I,J];
         END;

         BEGIN
         INTEGER AH,AW;
         SAFE INTEGER ARRAY I11[-2:AH←(HIG-HW-1)%IW-1, 0:AW←(WID-HW-1)%IW-1];
         IAV←IAV+INTOP(MEMORY[LOCATION(PIC)+MEMORY[LOCATION(PIC)+IORD+1]],
                       IW,I11[0,0],HW,HW);
         FOR I←0 STEP 1 UNTIL AH DO
         FOR J←0 STEP 1 UNTIL AW DO
            INTER[I*2+1,J*2+1]←I11[I,J];
         END;

      IAV←IAV%32;

      INTLOM(AH+1,AW+1,INTER[0,0]);  comment  flag local maxima;

      FHAV←0;

      FOR I←1 STEP 1 UNTIL AH-2 DO
      FOR J←1 STEP 1 UNTIL AW-1 DO
      IF (INTER[I,J] LAND 1)=1 ∧ INTER[I,J]>IAV THEN
         BEGIN
         REAL FXT,FYT,FIT;
         INTEGER L,H,M;

         FYT←((I+1)*HW+.5)/HIG;
         FXT←((J+1)*HW+.5)/WID;
         FIT←INTER[I,J];

         L←1; H←FHAV;
         WHILE L≤H DO IF FIT>FIV[M←(L+H)%2] THEN H←M-1 ELSE L←M+1;
         FHAV←(FHAV+1) MIN NFS;
         IF L≤FHAV THEN
            BEGIN
            FOR M←FHAV-1 STEP -1 UNTIL L DO
               BEGIN
               FXV[M+1]←FXV[M]; FYV[M+1]←FYV[M]; FIV[M+1]←FIV[M];
               END;
            FXV[L]←FXT; FYV[L]←FYT; FIV[L]←FIT;
            END;
         END;

      FOR I←1 STEP 1 UNTIL FHAV DO
         BEGIN
         MEMORY[LOCATION(FX)-1+I,REAL]←FXV[I];
         MEMORY[LOCATION(FY)-1+I,REAL]←FYV[I];
         END;
      NFS←FHAV;
      END;

   END;
REAL PROCEDURE LOCATE(REFERENCE INTEGER PIC1,PIC2; comment correlator;
		      REFERENCE REAL POSY,POSX; REAL LOY(0.0),LOX(0.0),HIY(1.0),HIX(1.0));

COMMENT applies the binary search correlation method to find a window
        described by PIC1 1 (a window set) in the whole of PIC2 (a reduced set).
	The best match in PIC2 is returned in POSX and POSY, the value of the
	match (0 to 1) is the value of LOCATE;

   BEGIN
   INTEGER N,WIN; REAL QUAL;

   WIN←MEMORY[LOCATION(PIC1)+MEMORY[LOCATION(PIC1)+1]+PCLN];
   POSY←(LOY+HIY)/2;  POSX←(LOX+HIX)/2;
   FOR N←PIC1 STEP -1 UNTIL 1 DO
      BEGIN
      INTEGER SIL,SIH,SJL,SJH, DIL,DIH,DJL,DJH, HWIN;

      HWIN←WIN%2;
      DO
         BEGIN
         SIL←SJL←WIN%2-HWIN; SIH←SJH←WIN%2+HWIN-1;
         POSX←(POSX MIN HIX) MAX LOX;
         POSY←(POSY MIN HIY) MAX LOY;

	 DIL←POSY*MEMORY[LOCATION(PIC2)+MEMORY[LOCATION(PIC2)+N]+PCLN];
	 DJL←POSX*MEMORY[LOCATION(PIC2)+MEMORY[LOCATION(PIC2)+N]+LNBY];
	 DIH←DIL+WIN; DJH←DJL+WIN;  DIL←DIL-WIN; DJL←DJL-WIN;

	 QUAL←NORCOR(MEMORY[LOCATION(PIC1)+MEMORY[LOCATION(PIC1)+N]],
		     SIL,SJL,SIH,SJH,
		     MEMORY[LOCATION(PIC2)+MEMORY[LOCATION(PIC2)+N]],
		     DIL,DJL,DIH,DJH);
         HWIN←HWIN%2;
         END
      UNTIL QUAL≥.65 ∨ HWIN≤1;

      POSY←0.5*(DIL+DIH)/MEMORY[LOCATION(PIC2)+MEMORY[LOCATION(PIC2)+N]+PCLN];
      POSX←0.5*(DJL+DJH)/MEMORY[LOCATION(PIC2)+MEMORY[LOCATION(PIC2)+N]+LNBY];
      END;

   RETURN(QUAL);
   END;